home *** CD-ROM | disk | FTP | other *** search
/ Programming Sound Cards / Programming Sound Cards.iso / sound_77 / soundx.c < prev    next >
Text File  |  1995-01-01  |  7KB  |  365 lines
  1. /***************************************************************************** 
  2. *    Produces a code based on the "Soundex" method originally developed 
  3. *          by M.K. Odell and R.C. Russell.  Algorithm can be found on page 
  4. *          392 of Knuths' book 'Sorting and Searching', volume 3 of 'The Art 
  5. *          of Computer Programming", Addison/Wesley publisher. 
  6. * 
  7. *    Program Name: soundx.c  
  8. *    coded by:     Richard R. Schafer  
  9. *
  10. *********** RELEASED INTO THE PUBLIC DOMAIN *********************************/ 
  11.  
  12. #include "nandef.h" 
  13. #include "extend.h" 
  14.  
  15. #define ISALPHA(c)  ((c) >= 'a' && (c) <= 'z' || (c) >= 'A' && (c) <= 'Z') 
  16. #define UPPER(c)    ((c) >= 'a' && (c) <= 'z' ? (c) - 32 : (c)) 
  17.  
  18. #define CODE_ALLOC  5   /** size of code sequence.  4 for code 1 for NIL**/ 
  19.  
  20. CLIPPER soundx() 
  21.  
  22.      { 
  23.      /******************************************** 
  24.      *  the type_defs:   Boolean 
  25.      *                   quant 
  26.      *                   byte 
  27.      *  are defined in the include file "nandef.h" 
  28.      ********************************************/ 
  29.  
  30.      Boolean error; 
  31.  
  32.      quant i;        /*  Both 'i' and 'b' are counters  */ 
  33.      quant b; 
  34.      quant name_size; 
  35.  
  36.  
  37.      /*  'name' is where we put the parameter and 'short_name' is
  38.  
  39.      where we'll put the string that doesn't contain anything
  40.  
  41.      but ALPHA characters and 'code' is where we'll put the
  42.  
  43.      soundex code that we are developing.    */
  44.  
  45.      byte *name;
  46.  
  47.      byte *short_name;
  48.  
  49.      byte *code;
  50.  
  51.  
  52.  
  53.      /* intialize our code holder */
  54.      code = NULL;
  55.  
  56.  
  57.  
  58.      /* If any of these are true, we didn't get a proper parameter */
  59.  
  60.      error = (PCOUNT != 1 || !ISCHAR(1) || _parclen(1) == 0);
  61.  
  62.  
  63.  
  64.      /*  If we don't have any errors we'll continue otherwise dropout */
  65.  
  66.      if (!error)
  67.  
  68.           {
  69.  
  70.           /* put the parameter passed into an array */
  71.  
  72.           name = _parc(1);
  73.  
  74.  
  75.  
  76.           /* determine the length the of parameter passed
  77.  
  78.           and add 1 to hold the NIL byte
  79.  
  80.           */
  81.  
  82.           name_size = (quant) (_parclen(1) + 1);
  83.  
  84.  
  85.  
  86.           /*  Now that we've got something to work with, lets
  87.  
  88.           convert it to a soundex code.  First we have to
  89.  
  90.           allocate some memory for the code to be placed into.
  91.  
  92.           We'll use the function '_exmgrab' to do just that.
  93.  
  94.           */
  95.  
  96.           code = _exmgrab(CODE_ALLOC);
  97.  
  98.  
  99.  
  100.           /*  Now we'll initialize all of our arrays to hold NILs  */
  101.  
  102.           for (i = 0;i < name_size;i++)
  103.  
  104.                {
  105.  
  106.                short_name[i] = NIL;
  107.                }
  108.  
  109.  
  110.  
  111.           for (i = 0;i < CODE_ALLOC;i++)
  112.  
  113.                {
  114.  
  115.                code[i] = NIL;
  116.  
  117.                }
  118.  
  119.  
  120.  
  121.  
  122.  
  123.           /* now let's get rid of everything we don't want
  124.  
  125.           if it isn't an alpha character, we'll
  126.  
  127.           get rid of it and convert all else to uppercase
  128.  
  129.           */
  130.  
  131.           for (i = 0,b = 0;i < name_size; i++)
  132.  
  133.                {
  134.  
  135.                if (! ISALPHA(name[i]))
  136.  
  137.                     {
  138.  
  139.                     continue;
  140.  
  141.                     }
  142.  
  143.                /* if it is a good character we'll place it into
  144.  
  145.                another array to work from and increment the
  146.  
  147.                second counter 'b'            */
  148.  
  149.                short_name[b] = UPPER(name[i]);
  150.  
  151.                b++;
  152.  
  153.                }
  154.  
  155.  
  156.  
  157.           /*  The first character gets used as is */
  158.  
  159.           code[0] = short_name[0];
  160.  
  161.  
  162.           /*  Then we convert the rest of the string to the proper
  163.  
  164.           soundex numbers according to the algorithm.  We'll stay in
  165.  
  166.           the loop until such time as we have either run out of
  167.  
  168.           characters to work with, or we have filled the code.
  169.  
  170.           */
  171.  
  172.           for (i=1,b=1;(short_name[i] != NIL) && (b < (CODE_ALLOC - 1));i++ )
  173.  
  174.                {
  175.  
  176.                switch (short_name[i])
  177.  
  178.                     {
  179.  
  180.                     /*  These are the characters that we want to skip,
  181.  
  182.                     so if we match one we'll just go round for the
  183.  
  184.                     next character
  185.  
  186.                     */
  187.  
  188.                     case 'A':
  189.  
  190.                     case 'E':
  191.  
  192.                     case 'H':
  193.  
  194.                     case 'I':
  195.  
  196.                     case 'O':
  197.  
  198.                     case 'U':
  199.  
  200.                     case 'W':
  201.  
  202.                     case 'Y':
  203.  
  204.                          break;
  205.  
  206.  
  207.  
  208.                     /*  If we match any of these, they're the good ones
  209.  
  210.                     so we'll assign a number to 'code' for them.
  211.  
  212.                     */
  213.                     case 'B':
  214.  
  215.                     case 'F':
  216.  
  217.                     case 'P':
  218.  
  219.                     case 'V':
  220.  
  221.                          code[b] = '1';
  222.  
  223.                          b++;
  224.  
  225.                          break;
  226.  
  227.                     case 'C':
  228.  
  229.                     case 'G':
  230.  
  231.                     case 'J':
  232.  
  233.                     case 'K':
  234.  
  235.                     case 'Q':
  236.  
  237.                     case 'S':
  238.  
  239.                     case 'X':
  240.  
  241.                     case 'Z':
  242.  
  243.                          code[b] = '2';
  244.  
  245.                          b++;
  246.  
  247.                          break;
  248.  
  249.                     case 'D':
  250.  
  251.                     case 'T':                     code[b] = '3';
  252.  
  253.                          b++;
  254.  
  255.                          break;
  256.  
  257.                     case 'L':
  258.  
  259.                          code[b] = '4';
  260.  
  261.                          b++; 
  262.  
  263.                          break;
  264.  
  265.                     case 'M':
  266.                     case 'N':
  267.  
  268.                          code[b] = '5';
  269.  
  270.                          b++;
  271.  
  272.                          break;
  273.  
  274.                     case 'R':
  275.  
  276.                          code[b] = '6';
  277.  
  278.                          b++;
  279.  
  280.                          break;
  281.  
  282.                     }
  283.  
  284.  
  285.  
  286.                /*  If we haven't gone beyond the last character in
  287.  
  288.                'short_name'.
  289.  
  290.                */
  291.  
  292.                if (short_name[i + 1] != NIL)
  293.  
  294.                     {
  295.  
  296.  
  297.  
  298.                     /*  Check to see if the next character in the
  299.  
  300.                     array is the same as the one we just
  301.  
  302.                     evaluated, if so, we want to skip over it.
  303.  
  304.                     */
  305.  
  306.                     if (short_name[i] == short_name[i + 1])
  307.  
  308.                          {
  309.  
  310.                          i++;
  311.  
  312.                          }
  313.  
  314.                     }
  315.  
  316.                }
  317.  
  318.  
  319.           }
  320.  
  321.      
  322.  
  323.           /*  If the code isn't filled, we want to pad it with zeroes  */
  324.  
  325.           if (b < 4)
  326.  
  327.                {
  328.  
  329.                for (;b < 4;b++)
  330.  
  331.                     {
  332.  
  333.                     code[b] = '0';
  334.  
  335.                     }
  336.  
  337.                }
  338.  
  339.  
  340.  
  341.           /*  Now we setup to return the code and then release the memory
  342.  
  343.           that we allocated.  We'll use the "_exmback" function to do that.
  344.  
  345.           */
  346.  
  347.           if (!error)
  348.  
  349.                _retc(code);
  350.  
  351.           else
  352.  
  353.                _retc("");
  354.  
  355.      
  356.  
  357.           if (code)
  358.  
  359.                _exmback(code,CODE_ALLOC);
  360.  
  361.  
  362.  
  363.      }
  364.  
  365.